{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "118e3b1d",
   "metadata": {},
   "source": [
    "# Customizing Your Neuron Models\n",
    "\n",
    "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/brainpy/brainpy/blob/master/docs_version2/tutorial_building/customize_neuron_models.ipynb)\n",
    "[![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/brainpy/brainpy/blob/master/docs_version2/tutorial_building/customize_neuron_models.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c68cbca",
   "metadata": {},
   "source": [
    "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn) @[Chaoming Wang](https://github.com/chaoming0625)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f783d7fb",
   "metadata": {},
   "source": [
    "The previous section shows all available models users can utilize by simply instantiating the abstract model. In following sections we will dive into details to illustrate how to build a neuron model with ``brainpy.dyn.NeuDyn``. Neurons are the most basic components in neural dynamics simulation. In BrainPy, `brainpy.dyn.NeuDyn` is used for neuron modeling."
   ]
  },
  {
   "cell_type": "code",
   "id": "aac4b858",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.610677Z",
     "start_time": "2025-10-06T03:49:49.854816Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "\n",
    "import brainpy as bp\n",
    "import brainpy.math as bm\n",
    "\n",
    "bm.set_platform('cpu')"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "id": "52f320c2ab5e60f3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.641836Z",
     "start_time": "2025-10-06T03:49:55.632374Z"
    }
   },
   "source": [
    "bp.__version__"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.0.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "id": "5d38f2b7",
   "metadata": {},
   "source": [
    "## ``brainpy.dyn.NeuDyn``"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6444c5ce",
   "metadata": {},
   "source": [
    "Generally, any neuron model can evolve continuously or discontinuously. \n",
    "Discontinuous evolution may be triggered by events, such as the reset of membrane potential. \n",
    "Moreover, it is common in a neural system that a dynamical system has different states, such as the excitable or refractory\n",
    "state in a [leaky integrate-and-fire (LIF) model](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.dyn.Lif.html). \n",
    "In this section, we will use two examples to illustrate how to capture these complexities in neuron modeling."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9520e950",
   "metadata": {},
   "source": [
    "Defining a neuron model in BrainPy is simple. You just need to inherit from ``brainpy.dyn.NeuDyn``, and satisfy the following two requirements:\n",
    "\n",
    "- Providing the `size` of the neural group in the constructor when initialize a new neural group class. `size` can be a integer referring to the number of neurons or a tuple/list of integers referring to the geometry of the neural group in different dimensions. According to the provided group ``size``, ``brainpy.dyn.NeuDyn`` will automatically calculate the total number ``num`` of neurons in this group.\n",
    "\n",
    "- Creating an `update()` function. Update function provides the rule how the neuron states are evolved from the current time $t$ to the next time $t+dt$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2993080",
   "metadata": {},
   "source": [
    "In the following part, a [Hodgkin-Huxley](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.dyn.HH.html) (HH) model is used as an example for illustration."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3095ec6f",
   "metadata": {},
   "source": [
    "## [Hodgkin–Huxley Model](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.dyn.HH.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5170763",
   "metadata": {},
   "source": [
    "The Hodgkin-Huxley (HH) model is a continuous-time dynamical system. It is one of the most successful mathematical models of a complex biological process that has ever been formulated. Changes of the membrane potential influence the conductance of different channels, elaborately modeling the neural activities in biological systems. Mathematically, the model is given by:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "    C_m \\frac {dV} {dt} &= -(\\bar{g}_{Na} m^3 h (V -E_{Na})\n",
    "    + \\bar{g}_K n^4 (V-E_K) + g_{leak} (V - E_{leak})) + I(t) \\quad\\quad(1) \\\\\n",
    "    \\frac {dx} {dt} &= \\alpha_x (1-x)  - \\beta_x, \\quad x\\in {\\rm{\\{m, h, n\\}}} \\quad\\quad(2) \\\\\n",
    "    &\\alpha_m(V) = \\frac {0.1(V+40)}{1-\\exp(\\frac{-(V + 40)} {10})} \\quad\\quad(3) \\\\\n",
    "    &\\beta_m(V) = 4.0 \\exp(\\frac{-(V + 65)} {18}) \\quad\\quad(4) \\\\\n",
    "    &\\alpha_h(V) = 0.07 \\exp(\\frac{-(V+65)}{20}) \\quad\\quad(5) \\\\\n",
    "    &\\beta_h(V) = \\frac 1 {1 + \\exp(\\frac{-(V + 35)} {10})} \\quad\\quad(6) \\\\\n",
    "    &\\alpha_n(V) = \\frac {0.01(V+55)}{1-\\exp(-(V+55)/10)} \\quad\\quad(7) \\\\\n",
    "    &\\beta_n(V) = 0.125 \\exp(\\frac{-(V + 65)} {80}) \\quad\\quad(8) \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "where $V$ is the membrane potential, $C_m$ is the membrane capacitance per unit area, $E_K$ and $E_{Na}$ are the potassium and sodium reversal potentials, respectively, $E_l$ is the leak reversal potential, $\\bar{g}_K$ and $\\bar{g}_{Na}$ are the potassium and sodium conductance per unit area, respectively, and $\\bar{g}_l$ is the leak conductance per unit area. Because the potassium and sodium channels are voltage-sensitive, according to the biological experiments, $m$, $n$ and $h$ are used to simulate the activation of the channels. Specially, $n$ measures the activation of potassium channels, and $m$  and $h$ measures the activation and inactivation of sodium channels, respectively. $\\alpha_{x}$ and $\\beta_{x}$ are rate constants for the ion channel x and depend exclusively on the membrane potential."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f438ae",
   "metadata": {},
   "source": [
    "To implement the HH model, variables should be specified. According to the above equations, the following state variables change with respect to time:\n",
    "- `V`: the membrane potential\n",
    "- `m`: the activation of sodium channels\n",
    "- `h`: the inactivation of sodium channels\n",
    "- `n`: the activation of potassium channels\n",
    "\n",
    "Besides, the spiking state and the last spiking time can also be recorded for statistic analysis:\n",
    "- ``spike``: whether a spike is produced\n",
    "- ``t_last_spike``: the last spiking time\n",
    "\n",
    "Based on these state variables, the HH model can be implemented as below."
   ]
  },
  {
   "cell_type": "code",
   "id": "3ea88e6d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.666802Z",
     "start_time": "2025-10-06T03:49:55.655589Z"
    }
   },
   "source": [
    "class HH(bp.dyn.NeuDyn):\n",
    "  def __init__(self, size, ENa=50., gNa=120., EK=-77., gK=36., EL=-54.387, gL=0.03,\n",
    "               V_th=20., C=1.0, **kwargs):\n",
    "    # providing the group \"size\" information\n",
    "    super(HH, self).__init__(size=size, **kwargs)\n",
    "\n",
    "    # initialize parameters\n",
    "    self.ENa = ENa\n",
    "    self.EK = EK\n",
    "    self.EL = EL\n",
    "    self.gNa = gNa\n",
    "    self.gK = gK\n",
    "    self.gL = gL\n",
    "    self.C = C\n",
    "    self.V_th = V_th\n",
    "\n",
    "    # initialize variables\n",
    "    self.V = bm.Variable(bm.random.randn(self.num) - 70.)\n",
    "    self.m = bm.Variable(0.5 * bm.ones(self.num))\n",
    "    self.h = bm.Variable(0.6 * bm.ones(self.num))\n",
    "    self.n = bm.Variable(0.32 * bm.ones(self.num))\n",
    "    self.spike = bm.Variable(bm.zeros(self.num, dtype=bool))\n",
    "    self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7)\n",
    "\n",
    "    # integral functions\n",
    "    self.int_V = bp.odeint(f=self.dV, method='exp_auto')\n",
    "    self.int_m = bp.odeint(f=self.dm, method='exp_auto')\n",
    "    self.int_h = bp.odeint(f=self.dh, method='exp_auto')\n",
    "    self.int_n = bp.odeint(f=self.dn, method='exp_auto')\n",
    "\n",
    "  def dV(self, V, t, m, h, n, Iext):\n",
    "    I_Na = (self.gNa * m ** 3.0 * h) * (V - self.ENa)\n",
    "    I_K = (self.gK * n ** 4.0) * (V - self.EK)\n",
    "    I_leak = self.gL * (V - self.EL)\n",
    "    dVdt = (- I_Na - I_K - I_leak + Iext) / self.C\n",
    "    return dVdt\n",
    "\n",
    "  def dm(self, m, t, V):\n",
    "    alpha = 0.1 * (V + 40) / (1 - bm.exp(-(V + 40) / 10))\n",
    "    beta = 4.0 * bm.exp(-(V + 65) / 18)\n",
    "    dmdt = alpha * (1 - m) - beta * m\n",
    "    return dmdt\n",
    "  \n",
    "  def dh(self, h, t, V):\n",
    "    alpha = 0.07 * bm.exp(-(V + 65) / 20.)\n",
    "    beta = 1 / (1 + bm.exp(-(V + 35) / 10))\n",
    "    dhdt = alpha * (1 - h) - beta * h\n",
    "    return dhdt\n",
    "\n",
    "  def dn(self, n, t, V):\n",
    "    alpha = 0.01 * (V + 55) / (1 - bm.exp(-(V + 55) / 10))\n",
    "    beta = 0.125 * bm.exp(-(V + 65) / 80)\n",
    "    dndt = alpha * (1 - n) - beta * n\n",
    "    return dndt\n",
    "\n",
    "  def update(self, x=None):\n",
    "    _t = bp.share['t']\n",
    "    _dt = bp.share['dt']\n",
    "    x = 0. if x is None else x\n",
    "    \n",
    "    # compute V, m, h, n\n",
    "    V = self.int_V(self.V, _t, self.m, self.h, self.n, x, dt=_dt)\n",
    "    self.h.value = self.int_h(self.h, _t, self.V, dt=_dt)\n",
    "    self.m.value = self.int_m(self.m, _t, self.V, dt=_dt)\n",
    "    self.n.value = self.int_n(self.n, _t, self.V, dt=_dt)\n",
    "\n",
    "    # update the spiking state and the last spiking time\n",
    "    self.spike.value = bm.logical_and(self.V < self.V_th, V >= self.V_th)\n",
    "    self.t_last_spike.value = bm.where(self.spike, _t, self.t_last_spike)\n",
    "\n",
    "    # update V\n",
    "    self.V.value = V"
   ],
   "outputs": [],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "id": "8d523fb3",
   "metadata": {},
   "source": [
    "When defining the HH model, equation (1) is accomplished by [brainpy.odeint](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.odeint.html) as an [ODEIntegrator](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.integrators.ode.ODEIntegrator.html#brainpy.integrators.ode.ODEIntegrator). The details are contained in the [Numerical Solvers for ODEs](../tutorial_toolbox/ode_numerical_solvers.ipynb) tutorial.\n",
    "\n",
    "The variables, which will be updated during dynamics simulation, should be packed as `brainpy.math.Variable` and thus can be processed by JIT compilers to accelerate simulation. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215292d2",
   "metadata": {},
   "source": [
    "In the following part, a [leaky integrate-and-fire](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.dyn.Lif.html) (LIF) model is introduced as another example for illustration."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d7d580",
   "metadata": {},
   "source": [
    "## [Leaky Integrate-and-Fire Model](https://brainpy.readthedocs.io/en/latest/apis/generated/brainpy.dyn.Lif.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f45c7805",
   "metadata": {},
   "source": [
    "The LIF model is the classical neuron model which contains a continuous process and a discontinous spike reset operation. \n",
    "Formally, it is given by:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\tau_m \\frac{dV}{dt} = - (V(t) - V_{rest}) + I(t)  \\quad\\quad (1) \\\\\n",
    "\\text{if} \\, V(t) \\gt V_{th}, V(t) =V_{rest} \\,\n",
    "\\text{after} \\, \\tau_{ref} \\,  \\text{ms}        \\quad\\quad (2)\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "where $V$ is the membrane potential, $V_{rest}$ is the rest membrane potential, $V_{th}$ is the spike threshold, $\\tau_m$ is the time constant, $\\tau_{ref}$ is the refractory time period, and $I$ is the time-variant synaptic inputs. \n",
    "\n",
    "The above two equations model the continuous change and the spiking of neurons, respectively. Moreover, it has multiple states: ``subthreshold`` state, and  ``spiking`` or ``refractory`` state.  The membrane potential $V$ is integrated according to equation (1) when it is below $V_{th}$. Once $V$ reaches the threshold $V_{th}$, according to equation (2), $V$ is reaet to $V_{rest}$, and the neuron enters the refractory period where the membrane potential $V$ will remain constant in the following $\\tau_{ref}$ ms."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f3f7d32",
   "metadata": {},
   "source": [
    "The neuronal variables, like the membrane potential and external input, can be captured by the following one variable:\n",
    "\n",
    "- ``V``: the membrane potential"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76fa0aa2",
   "metadata": {},
   "source": [
    "In order to define the different states of a LIF neuron, we define additional variables:\n",
    "\n",
    "- ``spike``: whether a spike is produced\n",
    "- ``refractory``: whether the neuron is in the refractory period\n",
    "- ``t_last_spike``: the last spiking time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50fbecbe",
   "metadata": {},
   "source": [
    "Based on these state variables, the LIF model can be implemented as below."
   ]
  },
  {
   "cell_type": "code",
   "id": "4961244a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.682921Z",
     "start_time": "2025-10-06T03:49:55.676828Z"
    }
   },
   "source": [
    "class LIF(bp.dyn.NeuDyn):\n",
    "  def __init__(self, size, V_rest=0., V_reset=-5., V_th=20., R=1., tau=10., t_ref=5., **kwargs):\n",
    "    super(LIF, self).__init__(size=size, **kwargs)\n",
    "\n",
    "    # initialize parameters\n",
    "    self.V_rest = V_rest\n",
    "    self.V_reset = V_reset\n",
    "    self.V_th = V_th\n",
    "    self.R = R\n",
    "    self.tau = tau\n",
    "    self.t_ref = t_ref\n",
    "\n",
    "    # initialize variables\n",
    "    self.V = bm.Variable(bm.random.randn(self.num) + V_reset)\n",
    "    self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7)\n",
    "    self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool))\n",
    "    self.spike = bm.Variable(bm.zeros(self.num, dtype=bool))\n",
    "\n",
    "    # integral function\n",
    "    self.integral = bp.odeint(f=self.derivative, method='exp_auto')\n",
    "\n",
    "  def derivative(self, V, t, Iext):\n",
    "    dvdt = (-V + self.V_rest + self.R * Iext) / self.tau\n",
    "    return dvdt\n",
    "\n",
    "  def update(self, x=None):\n",
    "    _t = bp.share['t']\n",
    "    _dt = bp.share['dt']\n",
    "    x = 0. if x is None else x\n",
    "    \n",
    "    # Whether the neurons are in the refractory period\n",
    "    refractory = (_t - self.t_last_spike) <= self.t_ref\n",
    "    \n",
    "    # compute the membrane potential\n",
    "    V = self.integral(self.V, _t, x, dt=_dt)\n",
    "    \n",
    "    # computed membrane potential is valid only when the neuron is not in the refractory period \n",
    "    V = bm.where(refractory, self.V, V)\n",
    "    \n",
    "    # update the spiking state\n",
    "    spike = self.V_th <= V\n",
    "    self.spike.value = spike\n",
    "    \n",
    "    # update the last spiking time\n",
    "    self.t_last_spike.value = bm.where(spike, _t, self.t_last_spike)\n",
    "    \n",
    "    # update the membrane potential and reset spiked neurons\n",
    "    self.V.value = bm.where(spike, self.V_reset, V)\n",
    "    \n",
    "    # update the refractory state\n",
    "    self.refractory.value = bm.logical_or(refractory, spike)"
   ],
   "outputs": [],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "id": "9b54438c",
   "metadata": {},
   "source": [
    "In above, the discontinous resetting is implemented with ``brainpy.math.where`` operation. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b80959f",
   "metadata": {},
   "source": [
    "## Instantiation and running"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05818ebb",
   "metadata": {},
   "source": [
    "Here, let's try to instantiate a ``HH`` neuron group:"
   ]
  },
  {
   "cell_type": "code",
   "id": "7afcd4ff",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.990364Z",
     "start_time": "2025-10-06T03:49:55.693818Z"
    }
   },
   "source": [
    "neu = HH(10)"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "id": "e6be8d3d",
   "metadata": {},
   "source": [
    "in which a neural group containing 10 HH neurons is generated."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d2604b",
   "metadata": {},
   "source": [
    "In brief, running any dynamical system instance should be accomplished with a runner, such like `brianpy.DSRunner`. The variables to be monitored and the input crrents to be applied in the simulation can be provided when initializing the runner."
   ]
  },
  {
   "cell_type": "code",
   "id": "9a291f2f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:55.998439Z",
     "start_time": "2025-10-06T03:49:55.995332Z"
    }
   },
   "source": [
    "runner = bp.DSRunner(neu, monitors=['V'])"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "id": "5f6f8bdc76159ee7",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "At each time step, we give the same input current:"
   ]
  },
  {
   "cell_type": "code",
   "id": "d031ec35f8a1b4ed",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:56.005443Z",
     "start_time": "2025-10-06T03:49:56.001899Z"
    }
   },
   "source": [
    "inputs = np.ones(int(200. / bm.get_dt())) * 6.  # 200 ms"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "id": "00385de1",
   "metadata": {},
   "source": [
    "Then the simulation can be performed with a given time period, and the simulation result can be visualized:"
   ]
  },
  {
   "cell_type": "code",
   "id": "f102b056",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:56.489990Z",
     "start_time": "2025-10-06T03:49:56.008638Z"
    }
   },
   "source": [
    "runner.run(inputs=inputs)  # the running time is 200 ms\n",
    "\n",
    "bp.visualize.line_plot(runner.mon.ts, runner.mon.V, show=True)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/2000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0a31398dbddb41e1ba11bd4f82112509"
      }
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from 'C:\\\\Users\\\\adadu\\\\miniconda3\\\\envs\\\\bdp\\\\Lib\\\\site-packages\\\\matplotlib\\\\pyplot.py'>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "id": "93208ac2",
   "metadata": {},
   "source": [
    "A LIF neural group can be instantiated and applied in simulation in a similar way:"
   ]
  },
  {
   "cell_type": "code",
   "id": "929d85e4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-06T03:49:56.946663Z",
     "start_time": "2025-10-06T03:49:56.768745Z"
    }
   },
   "source": [
    "group = LIF(10)\n",
    "\n",
    "runner = bp.DSRunner(group, monitors=['V'])\n",
    "\n",
    "inputs = np.ones(int(200. / bm.get_dt())) * 22.  # 200 ms\n",
    "runner.run(inputs=inputs)\n",
    "\n",
    "bp.visualize.line_plot(runner.mon.ts, runner.mon.V, show=True)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/2000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "01f3b84c4b9d4f09b597148d26276f4a"
      }
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from 'C:\\\\Users\\\\adadu\\\\miniconda3\\\\envs\\\\bdp\\\\Lib\\\\site-packages\\\\matplotlib\\\\pyplot.py'>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
